
# -*- coding: UTF-8 -*-
import random
import sys

sys.path.append("../Objets-Ali")

import entite

class Planete :
#Creation de la classe Planete
    def __init__ (self, systemeParent, ID, posX, posY, nom, seed, worldSize):
        self.posX = posX
        self.posY = posY
        self.systemeParent = systemeParent
        self.ID = ID
        self.nom = nom
        self.worldSize = worldSize
        self.listeRessources = []
        self.listeEntites = []
        self.typeRessources = ["fer", "petrole", "fertilite", "gaz", "titane", "cuivre", "or", "argent"]
        self.listeGisements = []
        self.placerGisement()
        self.positionsOccupees = []
        self.placerRessources()
        self.dimX = 55
        self.dimY = 55
        self.indexImagePlanete = random.randint(0, 6)
        self.laRessource = None
        
        # Lorsqu'un joueur possède la planete, self.joueur est le joueur propriétaire..
        self.joueur = None
        self.ressourcesJoueur = self.systemeParent.ressourcesJoueur
#        for nbRessource in range(len(self.typeRessources)):
#            self.ressourcesJoueur.append(0)
        
######################################
#
#      MÉTHODE DE GÉNÉRATION
#
######################################        
    def genererEmplacementDepart(self, nomJoueur, i):
        posX = 5
        posY = 5
        
        posX = posX + 60
        posY = posY + 60
        premierVehicule = entite.Vaisseau(posX, posY + i * 100, 0, nomJoueur, 10000 * self.systemeParent.ID + 1000 * self.ID + 10 * i)
        septiemeVehicule = entite.Croiseur(posX, posY + i * 100 + 60, 0, nomJoueur, 10000 * self.systemeParent.ID + 1000 * self.ID + 10 * i + 1)
        deuxiemeVehicule = entite.Tank(posX, posY + i * 100 + 120, 0, nomJoueur, 10000 * self.systemeParent.ID + 1000 * self.ID + 10 * i + 2)
        troisiemeVehicule = entite.Explorateur(posX, posY + i * 100 + 180, 0, nomJoueur, 10000 * self.systemeParent.ID + 1000 * self.ID + 10 * i + 3)
        quatriemeVehicule = entite.Transporteur(posX, posY + i * 100 + 240, 0, nomJoueur, 10000 * self.systemeParent.ID + 1000 * self.ID + 10 * i + 4)
        cinquiemeVehicule = entite.Fregate(posX, posY + i * 100 + 300, 0, nomJoueur, 10000 * self.systemeParent.ID + 1000 * self.ID + 10 * i + 5)
        sixiemeVehicule = entite.Colonisateur(posX, posY + i * 100 + 360, 0, nomJoueur, 10000 * self.systemeParent.ID + 1000 * self.ID + 10 * i + 6)

        #self.listeEntites.append(premierVehicule)
        self.listeEntites.append(deuxiemeVehicule)
        self.listeEntites.append(troisiemeVehicule)
        #self.listeEntites.append(quatriemeVehicule)
        #self.listeEntites.append(cinquiemeVehicule)
        self.listeEntites.append(sixiemeVehicule)
        #self.listeEntites.append(septiemeVehicule)

    
    def placerGisement(self):
        #la planete comporte 1000x1000 espaces possibles de ressources
        #on exécute la boucle pour chaque type de ressources
        
        self.ressourcePresente = False # variable servant a determiner si un certain type de ressource sera sur la planete ou non
        self.gisementsAplacer = 0
        self.ressourcesRares = ("or", "argent")
        self.ressourcesCommunes = ("titane", "cuivre")
        self.ressourcesDeBases = ("fer", "petrole", "fertilite", "gaz")
        
        for i in range(len(self.typeRessources)):
            #Ce ne sont pas toutes les ressources qui sont systematiquement sur toutes les planetes,
            #la boucle effectue un random sur chacun des types de ressources en focntion de sa rareté.
            #Dans le cas d'un systeme de depart, toutes les ressources de bases sont disponibles dans
            # 100% des cas.
            self.prob = random.random()*100 # probabilite sur 100 qu'une ressource soit presente
            
            if self.typeRessources[i] in self.ressourcesRares and self.prob > 95 and self.prob <= 100:
                self.ressourcePresente = True
                self.gisementsAplacer = 1
            elif self.typeRessources[i] in self.ressourcesDeBases:
                if self.systemeParent.sysDepart:
                    self.ressourcePresente = True
                    self.gisementsAplacer = random.randint(1, 5)
                elif self.prob >= 40 and self.prob <= 100 :
                    self.ressourcePresente = True
                    self.gisementsAplacer = random.randint(1, 5)   
            elif self.typeRessources[i] in self.ressourcesCommunes and self.prob >= 60 and self.prob <= 100:
                self.ressourcePresente = True
                self.gisementsAplacer = random.randint(1, 3)
            
            for j in range(self.gisementsAplacer):
                #ajoute le gisement et sa position dans la liste de gisements de la planete
                self.listeGisements.append(Gisements(self.typeRessources[i], random.randint(1, self.worldSize / 10) * 10, random.randint(1, self.worldSize / 10) * 10, 0))
            
            self.ressourcePresente = False
            self.gisementsAplacer = 0
			
    def placerRessources(self):
        #le point de départ est le point de gisement, les autres
        #spots de ressources sont créés autours
        for i in range(len(self.listeGisements)):
            #9 fois pour un gisement de 3x3
            for x in range(-1, 2):
                for y in range(-1, 2):
                    #à partir du centre, si la ressource peut être placée on l'ajoute a la liste de ressources
                    # et aux positions occupées pour éviter d'avoir des spots de la même ressource qui se chevauchent
                    if self.validerPositionRessource(self.listeGisements[i].posX + x * 10 - 5, self.listeGisements[i].posY + y * 10 - 5, self.listeGisements[i].type):
                        self.listeRessources.append(Ressource(self.listeGisements[i].type, self.listeGisements[i].posX + x * 10 - 5, self.listeGisements[i].posY + y * 10 - 5, 40))
                        self.positionsOccupees.append(Ressource(self.listeGisements[i].type, self.listeGisements[i].posX + x * 10 - 5, self.listeGisements[i].posY + y * 10 - 5, 40))
        self.positionsOccupees = []

    
    def validerPositionRessource(self, clicX, clicY, type):
        for position in self.positionsOccupees:
            if(clicX >= (position.posX - 10 / 2) and clicX <= (position.posX + 10 / 2) and clicY >= (position.posY - 10 / 2) and clicY <= (position.posY + 10 / 2)) and position.type == type:
                return False
        
        return True
    
    # méthode de test                   
    def listerGisements(self):
        for i in range(len(self.listeGisements)):
            print(str(self.listeGisements[i].type) + " " + str(self.listeGisements[i].posX) + " " + str(self.listeGisements[i].posY))
    
        print(len(self.listeGisements)) 
        n = input()
        
    # méthode de test
    def listerRessources(self):
        for i in range(len(self.listeRessources)):
            print(str(self.listeRessources[i].type) + " " + str(self.listeRessources[i].posX) + " " + str(self.listeRessources[i].posY) + " " + str(self.listeRessources[i].concentration))

        
                
######################################
#
#          MÉTHODE D'ACCÈS
#
######################################
    def constructionPossible(self,joueur):
        for objet in self.listeEntites:
            if objet.nom == "Colonisateur" and objet.joueur == joueur:
                return True
        return False


    def placePourConstruire(self, posX, posY, nom, dim):
        # Vérifie s'il n'est pas par dessus un autre bâtiment.
        for objet in self.listeEntites:
            if objet.typeEntite() == "Batiment":
                if posX + dim / 2 > objet.posX - objet.dimX / 2 and posX - dim / 2 < objet.posX + objet.dimX / 2 and posY + dim / 2 > objet.posY - objet.dimY / 2 and posY - dim / 2 < objet.posY + objet.dimY / 2:
                    return False

        # Vérifie si une mine est sur une ressource.
        if nom == "Mine":
            for ressources in self.listeRessources:
                if posX >= ressources.posX - ressources.size / 2 and posX <= ressources.posX + ressources.size / 2 and posY >= ressources.posY - ressources.size / 2 and posY <= ressources.posY + ressources.size / 2:
                    self.laRessource = ressources
                    return True
            return False
                
        return True
                

    def typeVue(self):
        return "Planete"
    

    def trouverEntiteParId(self, id):
        for entite in self.listeEntites:
            if entite.id == id:
                return entite
            
        return None
        
    def ressourceOuEntite(self, posX, posY):
        for i in range(len(self.listeEntites)):
            if self.listeEntites[i].posx == posX and self.listeEntites[i].posy == posY:
                return "Entite"
        for i in range(len(self.listeRessources)):
            if self.listeRessources[i].posX == posX and self.listeRessources[i].posY == posY:
                return "Ressource"
        return "none"

        
    def entiteSelectionne(self, posX, posY):
        for i in range(len(self.listeEntites)):
            if self.listeEntites[i].posx == posX and self.listeEntites[i].posy == posY:
                return self.listeEntites[i]
        
    def ressourceTerrainSelectionne(self, posX, posY):
        self.ressources = " "
        
        for ressource in self.listeRessources:
            if ressource.selection(posX, posY) == 1:
                self.ressources = self.ressources + ressource.type + " | "
        
        return self.ressources
    
    def selection(self, clicX, clicY): #Regarde si on clic sur l'unite
        if(clicX >= (self.posX - self.dimX / 2) and clicX <= (self.posX + self.dimX / 2) and clicY >= (self.posY - self.dimY / 2) and clicY <= (self.posY + self.dimY / 2)):
            return self.ID
        else:
            return - 1
            
            
######################################
#                                    #
#      MÉTHODE DE MODIFICATION       #
#                                    #
######################################

    def collecterRessources(self, joueur): # PAS TESTÉ  / Ajoute 1 pour chaque mine par ressource...
        for mine in self.listeEntites:
            #if isinstance(mine, entite.Mine):
            if mine.nom == "Mine" and mine.joueur == joueur:
                for ressource in self.listeRessources:
                    if ressource.selection(mine.posX, mine.posY) == 1:
                        self.systemeParent.ressourcesJoueur[self.typeRessources.index(ressource.type)] = self.systemeParent.ressourcesJoueur[self.typeRessources.index(ressource.type)] + 1
        self.ressourcesJoueur = self.systemeParent.ressourcesJoueur

        
class Ressource():
    def __init__(self, type, posX, posY, concentration):
        self.type = type
        self.posX = posX
        self.posY = posY
        self.size = 10
        self.concentration = concentration
        self.couleur = self.choixCouleur() # couleur a dessiner pour la vue
        
        
    def choixCouleur(self):
        if self.type == "fer":
            return "grey"
        elif self.type == "petrole":
            return "black"
        elif self.type == "titane":
            return "white"
        elif self.type == "or":
            return "gold"
        elif self.type == "argent":
            return "burlywood4"
        elif self.type == "fertilite":
            return "green"
        elif self.type == "cuivre":
            return "red"
        elif self.type == "gaz":
            return "LightPink"
    
    def selection(self, clicX , clicY):
        if(clicX >= (self.posX - self.size / 2) and clicX <= (self.posX + self.size / 2) and clicY >= (self.posY - self.size / 2) and clicY <= (self.posY + self.size / 2)):
             return 1
        else:
            return 0
    
class Gisements():
    def __init__(self, type, posX, posY, posZ):
        self.type = type
        self.posX = posX
        self.posY = posY
        self.posZ = posZ	
